#ifndef SINGLETON_H
#define SINGLETON_H

#include <iostream>
#include <memory>
#include <mutex>

/* 线程安全：

// 利用 C++11 标准保证局部静态变量初始化的线程安全性，无需手动加锁。
// 高效性：

// 只有在第一次调用 getInstance() 时才会创建实例，避免了不必要的开销。
// 简单性：

// 无需额外的同步代码，代码更简洁、可维护。
// 自动销毁：

// 自动管理生命周期，无需手动释放 Singleton 实例。

//C++11 局部静态变量初始化已经是线程安全的，双重检查锁定主要是为了兼容性和学习目的。实际使用中，优先考虑局部静态变量方式。
*/



// 模板化的线程安全 Singleton
template <typename T>
class Singleton_s {
public:
    // 获取实例的静态方法
    static T& getInstance() {
        static T instance; // C++11 局部静态变量，线程安全
        return instance;
    }

    // 删除拷贝构造和赋值操作符，防止实例被复制
    Singleton_s(const Singleton_s&) = delete;
    Singleton_s& operator=(const Singleton_s&) = delete;

protected:
    // 构造函数和析构函数为 protected，防止直接实例化或销毁
    Singleton_s() = default;
    ~Singleton_s() = default;
};


// 模板 Singleton 类
template <typename T>
class Singleton {
public:
    // 获取实例的静态方法
    static T* getInstance() {
        if (!instance_) { // 第一次检查
            std::lock_guard<std::mutex> lock(mutex_); // 加锁
            if (!instance_) { // 第二次检查
                instance_ = new T();
            }
        }
        return instance_;
    }

    // 删除拷贝构造函数和赋值操作符，防止拷贝
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

protected:
    // 构造函数和析构函数设置为 protected，防止直接实例化或销毁
    Singleton() = default;
    ~Singleton() = default;

private:
    static T* instance_;         // 静态实例指针
    static std::mutex mutex_;    // 静态互斥锁
};

// 初始化静态成员
template <typename T>
T* Singleton<T>::instance_ = nullptr;

template <typename T>
std::mutex Singleton<T>::mutex_;

#endif // SINGLETON_H
